}
int
-xc_get_pfn_list(int xc_handle, uint32_t domid, xen_pfn_t *pfn_buf,
+xc_get_pfn_list(int xc_handle, uint32_t domid, uint64_t *pfn_buf,
unsigned long max_pfns)
{
- return xc_ia64_get_pfn_list (xc_handle, domid, pfn_buf, 0, max_pfns);
+ return xc_ia64_get_pfn_list(xc_handle, domid, (xen_pfn_t *)pfn_buf,
+ 0, max_pfns);
}
long
struct xen_domctl domctl;
domctl.cmd = XEN_DOMCTL_getdomaininfo;
domctl.domain = (domid_t)domid;
- return (do_domctl(xc_handle, &domctl) < 0) ? -1 : domctl.u.getdomaininfo.max_pages;
+ return ((do_domctl(xc_handle, &domctl) < 0)
+ ? -1 : domctl.u.getdomaininfo.max_pages);
}
/*
DPRINTF("xc_get_pfn_list\n");
/* We know that the RMA is machine contiguous so lets just get the
* first MFN and fill the rest in ourselves */
- rc = xc_get_pfn_list(xc_handle, domid, *page_array, 1);
+ rc = xc_get_pfn_list(xc_handle, domid, (uint64_t *)*page_array, 1);
if (rc == -1) {
perror("Could not get the page frame list");
return -1;
dumpcore_rtn_t dump_rtn)
{
unsigned long nr_pages;
- xen_pfn_t *page_array = NULL;
+ uint64_t *page_array = NULL;
xc_dominfo_t info;
int i, nr_vcpus = 0;
char *dump_mem, *dump_mem_start = NULL;
sizeof(vcpu_guest_context_t)*nr_vcpus;
dummy_len = (sizeof(struct xc_core_header) +
(sizeof(vcpu_guest_context_t) * nr_vcpus) +
- (nr_pages * sizeof(xen_pfn_t)));
+ (nr_pages * sizeof(*page_array)));
header.xch_pages_offset = round_pgup(dummy_len);
sts = dump_rtn(args, (char *)&header, sizeof(struct xc_core_header));
if ( sts != 0 )
goto error_out;
- if ( (page_array = malloc(nr_pages * sizeof(xen_pfn_t))) == NULL )
+ if ( (page_array = malloc(nr_pages * sizeof(*page_array))) == NULL )
{
IPRINTF("Could not allocate memory\n");
goto error_out;
IPRINTF("Could not get the page frame list\n");
goto error_out;
}
- sts = dump_rtn(args, (char *)page_array, nr_pages * sizeof(xen_pfn_t));
+ sts = dump_rtn(args, (char *)page_array, nr_pages * sizeof(*page_array));
if ( sts != 0 )
goto error_out;
domctl.u.shadow_op.pages = pages;
domctl.u.shadow_op.mb = mb ? *mb : 0;
domctl.u.shadow_op.mode = mode;
- set_xen_guest_handle(domctl.u.shadow_op.dirty_bitmap, dirty_bitmap);
+ set_xen_guest_handle(domctl.u.shadow_op.dirty_bitmap,
+ (uint8_t *)dirty_bitmap);
rc = do_domctl(xc_handle, &domctl);
analysis_phase(xc_handle, dom, max_pfn, to_skip, 0);
/* We want zeroed memory so use calloc rather than malloc. */
- pfn_type = calloc(MAX_BATCH_SIZE, sizeof(*pfn_type));
- pfn_batch = calloc(MAX_BATCH_SIZE, sizeof(*pfn_batch));
+ pfn_type = calloc(MAX_BATCH_SIZE, sizeof(*pfn_type));
+ pfn_batch = calloc(MAX_BATCH_SIZE, sizeof(*pfn_batch));
if ((pfn_type == NULL) || (pfn_batch == NULL)) {
ERROR("failed to alloc memory for pfn_type and/or pfn_batch arrays");
goto out;
}
- if (xc_get_pfn_type_batch(xc_handle, dom, batch, pfn_type)) {
+ for ( j = 0; j < batch; j++ )
+ ((uint32_t *)pfn_type)[i] = pfn_type[i];
+ if ( xc_get_pfn_type_batch(xc_handle, dom, batch,
+ (uint32_t *)pfn_type) )
+ {
ERROR("get_pfn_type_batch failed");
goto out;
}
+ for ( j = batch-1; j >= 0; j-- )
+ pfn_type[i] = ((uint32_t *)pfn_type)[i];
for ( j = 0; j < batch; j++ )
{
/* NB: arr must be locked */
int xc_get_pfn_type_batch(int xc_handle,
- uint32_t dom, int num, unsigned long *arr)
+ uint32_t dom, int num, uint32_t *arr)
{
DECLARE_DOMCTL;
domctl.cmd = XEN_DOMCTL_getpageframeinfo2;
#ifndef __ia64__
int xc_get_pfn_list(int xc_handle,
uint32_t domid,
- xen_pfn_t *pfn_buf,
+ uint64_t *pfn_buf,
unsigned long max_pfns)
{
DECLARE_DOMCTL;
set_xen_guest_handle(domctl.u.getmemlist.buffer, pfn_buf);
#ifdef VALGRIND
- memset(pfn_buf, 0, max_pfns * sizeof(xen_pfn_t));
+ memset(pfn_buf, 0, max_pfns * sizeof(*pfn_buf));
#endif
- if ( lock_pages(pfn_buf, max_pfns * sizeof(xen_pfn_t)) != 0 )
+ if ( lock_pages(pfn_buf, max_pfns * sizeof(*pfn_buf)) != 0 )
{
PERROR("xc_get_pfn_list: pfn_buf lock failed");
return -1;
ret = do_domctl(xc_handle, &domctl);
- unlock_pages(pfn_buf, max_pfns * sizeof(xen_pfn_t));
-
-#if 0
-#ifdef DEBUG
- DPRINTF(("Ret for xc_get_pfn_list is %d\n", ret));
- if (ret >= 0) {
- int i, j;
- for (i = 0; i < domctl.u.getmemlist.num_pfns; i += 16) {
- DPRINTF("0x%x: ", i);
- for (j = 0; j < 16; j++)
- DPRINTF("0x%lx ", pfn_buf[i + j]);
- DPRINTF("\n");
- }
- }
-#endif
-#endif
+ unlock_pages(pfn_buf, max_pfns * sizeof(*pfn_buf));
return (ret < 0) ? -1 : domctl.u.getmemlist.num_pfns;
}
/* --------------------- */
/* XXX application state */
-static long nr_pages = 0;
-static unsigned long *page_array = NULL;
+static long nr_pages = 0;
+static uint64_t *page_array = NULL;
/*
to_ma(int cpu, uint64_t maddr)
{
if ( current_is_hvm && paging_enabled(&ctxt[cpu]) )
- maddr = (uint64_t)page_array[maddr >> PAGE_SHIFT] << PAGE_SHIFT;
+ maddr = page_array[maddr >> PAGE_SHIFT] << PAGE_SHIFT;
return maddr;
}
if ( nr_pages > 0 )
free(page_array);
nr_pages = npgs;
- if ( (page_array = malloc(nr_pages * sizeof(unsigned long))) == NULL )
+ if ( (page_array = malloc(nr_pages * sizeof(*page_array))) == NULL )
{
IPRINTF("Could not allocate memory\n");
return NULL;
if ( xc_domain_getinfo(xc_handle, domid, 1, &info) != 1 )
{
PERROR("Could not get domain info");
- goto out;
+ return rc;
}
/*
unsigned long xc_translate_foreign_address(int xc_handle, uint32_t dom,
int vcpu, unsigned long long virt);
-int xc_get_pfn_list(int xc_handle, uint32_t domid, xen_pfn_t *pfn_buf,
+int xc_get_pfn_list(int xc_handle, uint32_t domid, uint64_t *pfn_buf,
unsigned long max_pfns);
unsigned long xc_ia64_fpsr_default(void);
int xc_memory_op(int xc_handle, int cmd, void *arg);
int xc_get_pfn_type_batch(int xc_handle, uint32_t dom,
- int num, unsigned long *arr);
+ int num, uint32_t *arr);
/* Get current total pages allocated to a domain. */
struct domain *d = find_domain_by_id(op->domain);
unsigned long start_page = op->u.getmemlist.start_pfn;
unsigned long nr_pages = op->u.getmemlist.max_pfns;
- unsigned long mfn;
+ uint64_t mfn;
if ( d == NULL ) {
ret = -EINVAL;
}
/* Transfer and clear the shadow bitmap in 1kB chunks for L1 cache. */
-#define SHADOW_COPY_CHUNK (1024 / sizeof (unsigned long))
+#define SHADOW_COPY_CHUNK 1024
int shadow_mode_control(struct domain *d, xen_domctl_shadow_op_t *sc)
{
case XEN_DOMCTL_SHADOW_OP_CLEAN:
{
- int nbr_longs;
+ int nbr_bytes;
sc->stats.fault_count = atomic64_read(&d->arch.shadow_fault_count);
sc->stats.dirty_count = atomic64_read(&d->arch.shadow_dirty_count);
if (sc->pages > d->arch.shadow_bitmap_size)
sc->pages = d->arch.shadow_bitmap_size;
- nbr_longs = (sc->pages + BITS_PER_LONG - 1) / BITS_PER_LONG;
+ nbr_bytes = (sc->pages + 7) / 8;
- for (i = 0; i < nbr_longs; i += SHADOW_COPY_CHUNK) {
- int size = (nbr_longs - i) > SHADOW_COPY_CHUNK ?
- SHADOW_COPY_CHUNK : nbr_longs - i;
+ for (i = 0; i < nbr_bytes; i += SHADOW_COPY_CHUNK) {
+ int size = (nbr_bytes - i) > SHADOW_COPY_CHUNK ?
+ SHADOW_COPY_CHUNK : nbr_bytes - i;
- if (copy_to_guest_offset(sc->dirty_bitmap, i,
- d->arch.shadow_bitmap + i,
- size)) {
+ if (copy_to_guest_offset(
+ sc->dirty_bitmap, i,
+ (uint8_t *)d->arch.shadow_bitmap + i,
+ size)) {
rc = -EFAULT;
break;
}
- memset(d->arch.shadow_bitmap + i,
- 0, size * sizeof(unsigned long));
+ memset((uint8_t *)d->arch.shadow_bitmap + i, 0, size);
}
break;
if (sc->pages > d->arch.shadow_bitmap_size)
sc->pages = d->arch.shadow_bitmap_size;
- size = (sc->pages + BITS_PER_LONG - 1) / BITS_PER_LONG;
- if (copy_to_guest(sc->dirty_bitmap,
- d->arch.shadow_bitmap, size)) {
+ size = (sc->pages + 7) / 8;
+ if (copy_to_guest(sc->dirty_bitmap,
+ (uint8_t *)d->arch.shadow_bitmap, size)) {
rc = -EFAULT;
break;
}
int i;
struct domain *d = find_domain_by_id(domctl->domain);
unsigned long max_pfns = domctl->u.getmemlist.max_pfns;
- xen_pfn_t mfn;
+ uint64_t mfn;
struct list_head *list_ent;
ret = -EINVAL;
#include <asm/hvm/support.h>
#include <asm/processor.h>
#include <public/hvm/e820.h>
-#ifdef CONFIG_COMPAT
-#include <compat/xen.h>
-#endif
-
-#ifndef COMPAT
-#define _long long
-#define copy_from_xxx_offset copy_from_guest_offset
-#define copy_to_xxx_offset copy_to_guest_offset
-#endif
-_long arch_do_domctl(
+long arch_do_domctl(
struct xen_domctl *domctl,
XEN_GUEST_HANDLE(xen_domctl_t) u_domctl)
{
- _long ret = 0;
+ long ret = 0;
switch ( domctl->cmd )
{
case XEN_DOMCTL_getpageframeinfo2:
{
-#define GPF2_BATCH (PAGE_SIZE / sizeof(_long))
int n,j;
int num = domctl->u.getpageframeinfo2.num;
domid_t dom = domctl->domain;
struct domain *d;
- unsigned _long *l_arr;
+ uint32_t *arr32;
ret = -ESRCH;
if ( unlikely((d = find_domain_by_id(dom)) == NULL) )
break;
}
- l_arr = alloc_xenheap_page();
+ arr32 = alloc_xenheap_page();
ret = 0;
for ( n = 0; n < num; )
{
- int k = ((num-n)>GPF2_BATCH)?GPF2_BATCH:(num-n);
+ int k = PAGE_SIZE / 4;
+ if ( (num - n) < k )
+ k = num - n;
- if ( copy_from_xxx_offset(l_arr,
- domctl->u.getpageframeinfo2.array,
- n, k) )
+ if ( copy_from_guest_offset(arr32,
+ domctl->u.getpageframeinfo2.array,
+ n, k) )
{
ret = -EINVAL;
break;
for ( j = 0; j < k; j++ )
{
struct page_info *page;
- unsigned _long mfn = l_arr[j];
+ unsigned long mfn = arr32[j];
page = mfn_to_page(mfn);
if ( likely(mfn_valid(mfn) && get_page(page, d)) )
{
- unsigned _long type = 0;
+ unsigned long type = 0;
switch( page->u.inuse.type_info & PGT_type_mask )
{
if ( page->u.inuse.type_info & PGT_pinned )
type |= XEN_DOMCTL_PFINFO_LPINTAB;
- l_arr[j] |= type;
+ arr32[j] |= type;
put_page(page);
}
else
- l_arr[j] |= XEN_DOMCTL_PFINFO_XTAB;
+ arr32[j] |= XEN_DOMCTL_PFINFO_XTAB;
}
- if ( copy_to_xxx_offset(domctl->u.getpageframeinfo2.array,
- n, l_arr, k) )
+ if ( copy_to_guest_offset(domctl->u.getpageframeinfo2.array,
+ n, arr32, k) )
{
ret = -EINVAL;
break;
n += k;
}
- free_xenheap_page(l_arr);
+ free_xenheap_page(arr32);
put_domain(d);
}
int i;
struct domain *d = find_domain_by_id(domctl->domain);
unsigned long max_pfns = domctl->u.getmemlist.max_pfns;
- xen_pfn_t mfn;
+ uint64_t mfn;
struct list_head *list_ent;
ret = -EINVAL;
{
mfn = page_to_mfn(list_entry(
list_ent, struct page_info, list));
- if ( copy_to_xxx_offset(domctl->u.getmemlist.buffer,
- i, &mfn, 1) )
+ if ( copy_to_guest_offset(domctl->u.getmemlist.buffer,
+ i, &mfn, 1) )
{
ret = -EFAULT;
break;
ret = -EFAULT;
-#ifndef COMPAT
if ( copy_from_guest(c, domctl->u.hvmcontext.ctxt, 1) != 0 )
-#else
- if ( copy_from_guest(c,
- compat_handle_cast(domctl->u.hvmcontext.ctxt, void),
- 1) != 0 )
-#endif
goto sethvmcontext_out;
ret = arch_sethvm_ctxt(v, c);
if (arch_gethvm_ctxt(v, c) == -1)
ret = -EFAULT;
-#ifndef COMPAT
if ( copy_to_guest(domctl->u.hvmcontext.ctxt, c, 1) )
-#else
- if ( copy_to_guest(compat_handle_cast(domctl->u.hvmcontext.ctxt,
- void),
- c, 1) )
ret = -EFAULT;
-#endif
xfree(c);
return ret;
}
-#ifndef COMPAT
void arch_get_info_guest(struct vcpu *v, vcpu_guest_context_u c)
{
#ifdef CONFIG_COMPAT
memcpy(c.nat, &v->arch.guest_context, sizeof(*c.nat));
#ifdef CONFIG_COMPAT
else
- {
XLAT_vcpu_guest_context(c.cmp, &v->arch.guest_context);
- }
#endif
if ( is_hvm_vcpu(v) )
c(vm_assist = v->domain->vm_assist);
#undef c
}
-#endif
/*
* Local variables:
if ( likely(peek) )
{
if ( copy_to_guest_offset(
- sc->dirty_bitmap,
- i/(8*sizeof(unsigned long)),
- d->arch.shadow.dirty_bitmap+(i/(8*sizeof(unsigned long))),
- (bytes+sizeof(unsigned long)-1) / sizeof(unsigned long)) )
+ sc->dirty_bitmap, i/8,
+ (uint8_t *)d->arch.shadow.dirty_bitmap + (i/8), bytes) )
{
- rv = -EFAULT;
- goto out;
+ rv = -EFAULT;
+ goto out;
}
}
if ( clean )
- memset(d->arch.shadow.dirty_bitmap + (i/(8*sizeof(unsigned long))),
- 0, bytes);
+ memset((uint8_t *)d->arch.shadow.dirty_bitmap + (i/8), 0, bytes);
}
#undef CHUNK
#include <asm/hvm/support.h>
#include <asm/processor.h>
-#ifndef COMPAT
-typedef long ret_t;
-#endif
-
-ret_t arch_do_sysctl(
+long arch_do_sysctl(
struct xen_sysctl *sysctl, XEN_GUEST_HANDLE(xen_sysctl_t) u_sysctl)
{
- ret_t ret = 0;
+ long ret = 0;
switch ( sysctl->cmd )
{
obj-$(CONFIG_COMPAT) += compat.o
obj-$(CONFIG_COMPAT) += domain.o
-obj-$(CONFIG_COMPAT) += domctl.o
obj-$(CONFIG_COMPAT) += physdev.o
obj-$(CONFIG_COMPAT) += platform_hypercall.o
-obj-$(CONFIG_COMPAT) += sysctl.o
ifeq ($(CONFIG_COMPAT),y)
# extra dependencies
.quad CFLT14,CFIX14
.previous
+compat_domctl:
+compat_sysctl:
+
.section .rodata, "a", @progbits
ENTRY(compat_hypercall_table)
.quad do_event_channel_op
.quad compat_physdev_op
.quad do_hvm_op
- .quad compat_sysctl /* 35 */
- .quad compat_domctl
+ .quad do_sysctl /* 35 */
+ .quad do_domctl
.quad compat_kexec_op
.rept NR_hypercalls-((.-compat_hypercall_table)/8)
.quad compat_ni_hypercall
+++ /dev/null
-/******************************************************************************
- * Arch-specific compatibility domctl.c
- */
-
-#include <xen/config.h>
-#include <compat/domctl.h>
-#include <xen/guest_access.h>
-#include <asm/shadow.h>
-
-DEFINE_XEN_GUEST_HANDLE(compat_domctl_t);
-#define xen_domctl compat_domctl
-#define xen_domctl_t compat_domctl_t
-#define arch_do_domctl(x, h) arch_compat_domctl(x, _##h)
-
-static int compat_shadow_domctl(struct domain *d,
- compat_domctl_shadow_op_t *csc,
- XEN_GUEST_HANDLE(void) u_domctl)
-{
- xen_domctl_shadow_op_t nsc;
- int rc, mode;
-
-#define XLAT_domctl_shadow_op_HNDL_dirty_bitmap(_d_, _s_) \
- do \
- { \
- if ( (_s_)->op != XEN_DOMCTL_SHADOW_OP_CLEAN \
- && (_s_)->op != XEN_DOMCTL_SHADOW_OP_PEEK ) \
- { \
- set_xen_guest_handle((_d_)->dirty_bitmap, NULL); \
- mode = -1; \
- } \
- else if ( compat_handle_is_null((_s_)->dirty_bitmap) \
- || (((_s_)->pages - 1) \
- & (BITS_PER_LONG - COMPAT_BITS_PER_LONG)) \
- == BITS_PER_LONG - COMPAT_BITS_PER_LONG ) \
- { \
- XEN_GUEST_HANDLE(void) tmp; \
- guest_from_compat_handle(tmp, (_s_)->dirty_bitmap); \
- (_d_)->dirty_bitmap = guest_handle_cast(tmp, ulong); \
- mode = 0; \
- } \
- else if ( (_s_)->pages > COMPAT_ARG_XLAT_SIZE * 8 ) \
- { \
- printk("Cannot translate compatibility mode XEN_DOMCTL_SHADOW_OP_{CLEAN,PEEK} (0x%lX)\n", \
- (_s_)->pages); \
- return -E2BIG; \
- } \
- else \
- { \
- set_xen_guest_handle((_d_)->dirty_bitmap, \
- (void *)COMPAT_ARG_XLAT_VIRT_START(current->vcpu_id)); \
- mode = 1; \
- } \
- } while (0)
- XLAT_domctl_shadow_op(&nsc, csc);
-#undef XLAT_domctl_shadow_op_HNDL_dirty_bitmap
- rc = shadow_domctl(d, &nsc, u_domctl);
- if ( rc != __HYPERVISOR_domctl )
- {
- BUG_ON(rc > 0);
-#define XLAT_domctl_shadow_op_HNDL_dirty_bitmap(_d_, _s_) \
- do \
- { \
- if ( rc == 0 \
- && mode > 0 \
- && copy_to_compat((_d_)->dirty_bitmap, \
- (unsigned int *)(_s_)->dirty_bitmap.p, \
- ((_s_)->pages + COMPAT_BITS_PER_LONG - 1) / COMPAT_BITS_PER_LONG) ) \
- rc = -EFAULT; \
- } while (0)
- XLAT_domctl_shadow_op(csc, &nsc);
-#undef XLAT_domctl_shadow_op_HNDL_dirty_bitmap
- }
- return rc;
-}
-#define xen_domctl_shadow_op compat_domctl_shadow_op
-#define xen_domctl_shadow_op_t compat_domctl_shadow_op_t
-#define shadow_domctl(d, sc, u) compat_shadow_domctl(d, sc, u)
-
-#define xen_domctl_ioport_permission compat_domctl_ioport_permission
-#define xen_domctl_ioport_permission_t compat_domctl_ioport_permission_t
-
-#define xen_domctl_getpageframeinfo compat_domctl_getpageframeinfo
-#define xen_domctl_getpageframeinfo_t compat_domctl_getpageframeinfo_t
-
-#define xen_domctl_getpageframeinfo2 compat_domctl_getpageframeinfo2
-#define xen_domctl_getpageframeinfo2_t compat_domctl_getpageframeinfo2_t
-
-#define xen_domctl_getmemlist compat_domctl_getmemlist
-#define xen_domctl_getmemlist_t compat_domctl_getmemlist_t
-#define xen_pfn_t compat_pfn_t
-
-#define xen_domctl_hypercall_init compat_domctl_hypercall_init
-#define xen_domctl_hypercall_init_t compat_domctl_hypercall_init_t
-
-#define COMPAT
-#define _XEN_GUEST_HANDLE(t) XEN_GUEST_HANDLE(t)
-#define _long int
-#define copy_from_xxx_offset copy_from_compat_offset
-#define copy_to_xxx_offset copy_to_compat_offset
-
-#include "../domctl.c"
-
-/*
- * Local variables:
- * mode: C
- * c-set-style: "BSD"
- * c-basic-offset: 4
- * tab-width: 4
- * indent-tabs-mode: nil
- * End:
- */
+++ /dev/null
-/******************************************************************************
- * Arch-specific compatibility sysctl.c
- */
-
-#include <xen/config.h>
-#include <compat/sysctl.h>
-
-DEFINE_XEN_GUEST_HANDLE(compat_sysctl_t);
-#define xen_sysctl compat_sysctl
-#define xen_sysctl_t compat_sysctl_t
-#define arch_do_sysctl(x, h) arch_compat_sysctl(x, _##h)
-
-#define xen_sysctl_physinfo compat_sysctl_physinfo
-#define xen_sysctl_physinfo_t compat_sysctl_physinfo_t
-
-#define xen_sysctl_ioport_emulation compat_sysctl_ioport_emulation
-#define xen_sysctl_ioport_emulation_t compat_sysctl_ioport_emulation_t
-
-#define COMPAT
-#define _XEN_GUEST_HANDLE(t) XEN_GUEST_HANDLE(t)
-typedef int ret_t;
-
-#include "../sysctl.c"
-
-/*
- * Local variables:
- * mode: C
- * c-set-style: "BSD"
- * c-basic-offset: 4
- * tab-width: 4
- * indent-tabs-mode: nil
- * End:
- */
obj-y += domain.o
-obj-y += domctl.o
obj-y += kernel.o
obj-y += memory.o
obj-y += multicall.o
-obj-y += sysctl.o
obj-y += xlat.o
# extra dependencies
-domctl.o: ../domctl.c
kernel.o: ../kernel.c
multicall.o: ../multicall.c
-sysctl.o: ../sysctl.c
+++ /dev/null
-/******************************************************************************
- * compat/domctl.c
- */
-
-#include <xen/config.h>
-#include <compat/domctl.h>
-#include <xen/sched.h>
-#include <xen/cpumask.h>
-#include <asm/uaccess.h>
-
-DEFINE_XEN_GUEST_HANDLE(compat_domctl_t);
-#define xen_domctl compat_domctl
-#define xen_domctl_t compat_domctl_t
-#define do_domctl(h) compat_domctl(_##h)
-#define arch_do_domctl(x, h) arch_compat_domctl(x, _##h)
-
-#define xen_domain_handle_t compat_domain_handle_t
-
-#define xen_domctl_vcpucontext compat_domctl_vcpucontext
-#define xen_domctl_vcpucontext_t compat_domctl_vcpucontext_t
-
-#define xen_domctl_createdomain compat_domctl_createdomain
-#define xen_domctl_createdomain_t compat_domctl_createdomain_t
-
-#define xen_domctl_max_vcpus compat_domctl_max_vcpus
-#define xen_domctl_max_vcpus_t compat_domctl_max_vcpus_t
-
-static void cpumask_to_compat_ctl_cpumap(
- struct compat_ctl_cpumap *cmpctl_cpumap, cpumask_t *cpumask)
-{
- unsigned int guest_bytes, copy_bytes, i;
- /*static const*/ uint8_t zero = 0;
-
- if ( compat_handle_is_null(cmpctl_cpumap->bitmap) )
- return;
-
- guest_bytes = (cmpctl_cpumap->nr_cpus + 7) / 8;
- copy_bytes = min_t(unsigned int, guest_bytes, (NR_CPUS + 7) / 8);
-
- copy_to_compat(cmpctl_cpumap->bitmap,
- (uint8_t *)cpus_addr(*cpumask),
- copy_bytes);
-
- for ( i = copy_bytes; i < guest_bytes; i++ )
- copy_to_compat_offset(cmpctl_cpumap->bitmap, i, &zero, 1);
-}
-#define cpumask_to_xenctl_cpumap cpumask_to_compat_ctl_cpumap
-
-void compat_ctl_cpumap_to_cpumask(
- cpumask_t *cpumask, struct compat_ctl_cpumap *cmpctl_cpumap)
-{
- unsigned int guest_bytes, copy_bytes;
-
- guest_bytes = (cmpctl_cpumap->nr_cpus + 7) / 8;
- copy_bytes = min_t(unsigned int, guest_bytes, (NR_CPUS + 7) / 8);
-
- cpus_clear(*cpumask);
-
- if ( compat_handle_is_null(cmpctl_cpumap->bitmap) )
- return;
-
- copy_from_compat((uint8_t *)cpus_addr(*cpumask),
- cmpctl_cpumap->bitmap,
- copy_bytes);
-}
-#define xenctl_cpumap_to_cpumask compat_ctl_cpumap_to_cpumask
-
-#define xen_domctl_vcpuaffinity compat_domctl_vcpuaffinity
-#define xen_domctl_vcpuaffinity_t compat_domctl_vcpuaffinity_t
-
-static int compat_sched_adjust(struct domain *d,
- struct compat_domctl_scheduler_op *cop)
-{
- struct xen_domctl_scheduler_op nop;
- int ret;
- enum XLAT_domctl_scheduler_op_u u;
-
- switch ( cop->sched_id )
- {
- case XEN_SCHEDULER_SEDF: u = XLAT_domctl_scheduler_op_u_sedf; break;
- case XEN_SCHEDULER_CREDIT: u = XLAT_domctl_scheduler_op_u_credit; break;
- default: return -EINVAL;
- }
- XLAT_domctl_scheduler_op(&nop, cop);
- ret = sched_adjust(d, &nop);
- XLAT_domctl_scheduler_op(cop, &nop);
-
- return ret;
-}
-#define sched_adjust(d, op) compat_sched_adjust(d, op)
-#define xen_domctl_scheduler_op compat_domctl_scheduler_op
-#define xen_domctl_scheduler_op_t compat_domctl_scheduler_op_t
-
-#define xen_domctl_getdomaininfo compat_domctl_getdomaininfo
-#define xen_domctl_getdomaininfo_t compat_domctl_getdomaininfo_t
-#define getdomaininfo(d, i) compat_getdomaininfo(d, i)
-
-#define xen_domctl_getvcpuinfo compat_domctl_getvcpuinfo
-#define xen_domctl_getvcpuinfo_t compat_domctl_getvcpuinfo_t
-
-#define xen_domctl_max_mem compat_domctl_max_mem
-#define xen_domctl_max_mem_t compat_domctl_max_mem_t
-
-#define xen_domctl_setdomainhandle compat_domctl_setdomainhandle
-#define xen_domctl_setdomainhandle_t compat_domctl_setdomainhandle_t
-
-#define xen_domctl_setdebugging compat_domctl_setdebugging
-#define xen_domctl_setdebugging_t compat_domctl_setdebugging_t
-
-#define xen_domctl_irq_permission compat_domctl_irq_permission
-#define xen_domctl_irq_permission_t compat_domctl_irq_permission_t
-
-#define xen_domctl_iomem_permission compat_domctl_iomem_permission
-#define xen_domctl_iomem_permission_t compat_domctl_iomem_permission_t
-
-#define xen_domctl_settimeoffset compat_domctl_settimeoffset
-#define xen_domctl_settimeoffset_t compat_domctl_settimeoffset_t
-
-#define COMPAT
-#define _XEN_GUEST_HANDLE(t) XEN_GUEST_HANDLE(t)
-#define _u_domctl u_domctl
-//#undef guest_handle_cast
-//#define guest_handle_cast compat_handle_cast
-//#define copy_to_xxx_offset copy_to_compat_offset
-typedef int ret_t;
-
-#include "../domctl.c"
-
-/*
- * Local variables:
- * mode: C
- * c-set-style: "BSD"
- * c-basic-offset: 4
- * tab-width: 4
- * indent-tabs-mode: nil
- * End:
- */
+++ /dev/null
-/******************************************************************************
- * compat/sysctl.c
- */
-
-#include <xen/config.h>
-#include <compat/sysctl.h>
-#include <xen/domain.h>
-#include <xen/guest_access.h>
-#include <xen/perfc.h>
-#include <xen/trace.h>
-
-DEFINE_XEN_GUEST_HANDLE(compat_sysctl_t);
-#define xen_sysctl compat_sysctl
-#define xen_sysctl_t compat_sysctl_t
-#define do_sysctl(h) compat_sysctl(_##h)
-#define arch_do_sysctl(x, h) arch_compat_sysctl(x, _##h)
-
-#define xen_sysctl_readconsole compat_sysctl_readconsole
-#define xen_sysctl_readconsole_t compat_sysctl_readconsole_t
-
-static int compat_tb_control(struct compat_sysctl_tbuf_op *cmp_tbc)
-{
- struct xen_sysctl_tbuf_op nat_tbc;
- int ret;
-
-#define XLAT_ctl_cpumap_HNDL_bitmap(_d_, _s_) \
- guest_from_compat_handle((_d_)->bitmap, (_s_)->bitmap)
- XLAT_sysctl_tbuf_op(&nat_tbc, cmp_tbc);
-#undef XLAT_ctl_cpumap_HNDL_bitmap
- ret = tb_control(&nat_tbc);
-#define XLAT_ctl_cpumap_HNDL_bitmap(_d_, _s_) ((void)0)
- XLAT_sysctl_tbuf_op(cmp_tbc, &nat_tbc);
-#undef XLAT_ctl_cpumap_HNDL_bitmap
- return ret;
-}
-#define xen_sysctl_tbuf_op compat_sysctl_tbuf_op
-#define xen_sysctl_tbuf_op_t compat_sysctl_tbuf_op_t
-#define tb_control(p) compat_tb_control(p)
-
-#define xen_sysctl_sched_id compat_sysctl_sched_id
-#define xen_sysctl_sched_id_t compat_sysctl_sched_id_t
-
-#define xen_sysctl_getdomaininfolist compat_sysctl_getdomaininfolist
-#define xen_sysctl_getdomaininfolist_t compat_sysctl_getdomaininfolist_t
-#define xen_domctl_getdomaininfo compat_domctl_getdomaininfo
-#define xen_domctl_getdomaininfo_t compat_domctl_getdomaininfo_t
-#define getdomaininfo(d, i) compat_getdomaininfo(d, i)
-
-#ifdef PERF_COUNTERS
-static int compat_perfc_control(struct compat_sysctl_perfc_op *cmp_pc)
-{
- CHECK_sysctl_perfc_desc;
- CHECK_TYPE(sysctl_perfc_val);
- struct xen_sysctl_perfc_op nat_pc;
- int ret;
-
-#define XLAT_sysctl_perfc_op_HNDL_desc(_d_, _s_) \
- guest_from_compat_handle((_d_)->desc, (_s_)->desc)
-#define XLAT_sysctl_perfc_op_HNDL_val(_d_, _s_) \
- guest_from_compat_handle((_d_)->val, (_s_)->val)
- XLAT_sysctl_perfc_op(&nat_pc, cmp_pc);
-#undef XLAT_sysctl_perfc_op_HNDL_val
-#undef XLAT_sysctl_perfc_op_HNDL_desc
- ret = perfc_control(&nat_pc);
-#define XLAT_sysctl_perfc_op_HNDL_desc(_d_, _s_)
-#define XLAT_sysctl_perfc_op_HNDL_val(_d_, _s_)
- XLAT_sysctl_perfc_op(cmp_pc, &nat_pc);
-#undef XLAT_sysctl_perfc_op_HNDL_val
-#undef XLAT_sysctl_perfc_op_HNDL_desc
- return ret;
-}
-#define xen_sysctl_perfc_op compat_sysctl_perfc_op
-#define xen_sysctl_perfc_op_t compat_sysctl_perfc_op_t
-#define perfc_control(p) compat_perfc_control(p)
-#endif
-
-#define COMPAT
-#define _XEN_GUEST_HANDLE(t) XEN_GUEST_HANDLE(t)
-#define _u_sysctl u_sysctl
-#undef guest_handle_cast
-#define guest_handle_cast compat_handle_cast
-#define copy_to_xxx_offset copy_to_compat_offset
-typedef int ret_t;
-
-#include "../sysctl.c"
-
-/*
- * Local variables:
- * mode: C
- * c-set-style: "BSD"
- * c-basic-offset: 4
- * tab-width: 4
- * indent-tabs-mode: nil
- * End:
- */
#include <asm/debugger.h>
#include <public/sched.h>
#include <public/vcpu.h>
-#ifdef CONFIG_COMPAT
-#include <compat/domctl.h>
-#endif
/* Both these structures are protected by the domlist_lock. */
DEFINE_RWLOCK(domlist_lock);
}
}
-
-/*
- * set_info_guest is used for final setup, launching, and state modification
- * of domains other than domain 0. ie. the domains that are being built by
- * the userspace dom0 domain builder.
- */
-int set_info_guest(struct domain *d,
- xen_domctl_vcpucontext_u vcpucontext)
-{
- int rc = 0;
- vcpu_guest_context_u c;
-#ifdef CONFIG_COMPAT
- CHECK_FIELD(domctl_vcpucontext, vcpu);
-#endif
- unsigned long vcpu = vcpucontext.nat->vcpu;
- struct vcpu *v;
-
- if ( (vcpu >= MAX_VIRT_CPUS) || ((v = d->vcpu[vcpu]) == NULL) )
- return -EINVAL;
-
- if ( IS_COMPAT(v->domain)
- ? compat_handle_is_null(vcpucontext.cmp->ctxt)
- : guest_handle_is_null(vcpucontext.nat->ctxt) )
- return vcpu_reset(v);
-
-#ifdef CONFIG_COMPAT
- BUILD_BUG_ON(sizeof(struct vcpu_guest_context)
- < sizeof(struct compat_vcpu_guest_context));
-#endif
- if ( (c.nat = xmalloc(struct vcpu_guest_context)) == NULL )
- return -ENOMEM;
-
- domain_pause(d);
-
- if ( !IS_COMPAT(v->domain) )
- {
- if ( !IS_COMPAT(current->domain)
- ? copy_from_guest(c.nat, vcpucontext.nat->ctxt, 1)
-#ifndef CONFIG_COMPAT
- : 0 )
-#else
- : copy_from_guest(c.nat,
- compat_handle_cast(vcpucontext.cmp->ctxt,
- void),
- 1) )
-#endif
- rc = -EFAULT;
- }
-#ifdef CONFIG_COMPAT
- else
- {
- if ( !IS_COMPAT(current->domain)
- ? copy_from_guest(c.cmp,
- guest_handle_cast(vcpucontext.nat->ctxt, void),
- 1)
- : copy_from_compat(c.cmp, vcpucontext.cmp->ctxt, 1) )
- rc = -EFAULT;
- }
-#endif
-
- if ( rc == 0 )
- rc = arch_set_info_guest(v, c);
-
- domain_unpause(d);
-
- xfree(c.nat);
- return rc;
-}
-
int boot_vcpu(struct domain *d, int vcpuid, vcpu_guest_context_u ctxt)
{
struct vcpu *v = d->vcpu[vcpuid];
#include <xen/iocap.h>
#include <xen/guest_access.h>
#include <xen/bitmap.h>
-#ifdef CONFIG_COMPAT
-#include <xen/compat.h>
-#endif
#include <asm/current.h>
#include <public/domctl.h>
#include <acm/acm_hooks.h>
-#ifndef COMPAT
-typedef long ret_t;
-#define copy_to_xxx_offset copy_to_guest_offset
-#endif
-
-extern ret_t arch_do_domctl(
+extern long arch_do_domctl(
struct xen_domctl *op, XEN_GUEST_HANDLE(xen_domctl_t) u_domctl);
-#ifndef COMPAT
-
void cpumask_to_xenctl_cpumap(
struct xenctl_cpumap *xenctl_cpumap, cpumask_t *cpumask)
{
bitmap_byte_to_long(cpus_addr(*cpumask), bytemap, NR_CPUS);
}
-#endif /* COMPAT */
-
static inline int is_free_domid(domid_t dom)
{
struct domain *d;
return cpu;
}
-ret_t do_domctl(XEN_GUEST_HANDLE(xen_domctl_t) u_domctl)
+long do_domctl(XEN_GUEST_HANDLE(xen_domctl_t) u_domctl)
{
- ret_t ret = 0;
+ long ret = 0;
struct xen_domctl curop, *op = &curop;
void *ssid = NULL; /* save security ptr between pre and post/fail hooks */
static DEFINE_SPINLOCK(domctl_lock);
case XEN_DOMCTL_setvcpucontext:
{
struct domain *d = find_domain_by_id(op->domain);
+ vcpu_guest_context_u c = { .nat = NULL };
+ unsigned int vcpu = op->u.vcpucontext.vcpu;
+ struct vcpu *v;
+
ret = -ESRCH;
- if ( d != NULL )
+ if ( d == NULL )
+ break;
+
+ ret = -EINVAL;
+ if ( (vcpu >= MAX_VIRT_CPUS) || ((v = d->vcpu[vcpu]) == NULL) )
+ goto svc_out;
+
+ if ( guest_handle_is_null(op->u.vcpucontext.ctxt) )
{
- ret = set_info_guest(d, &op->u.vcpucontext);
- put_domain(d);
+ ret = vcpu_reset(v);
+ goto svc_out;
+ }
+
+#ifdef CONFIG_COMPAT
+ BUILD_BUG_ON(sizeof(struct vcpu_guest_context)
+ < sizeof(struct compat_vcpu_guest_context));
+#endif
+ ret = -ENOMEM;
+ if ( (c.nat = xmalloc(struct vcpu_guest_context)) == NULL )
+ goto svc_out;
+
+ if ( !IS_COMPAT(v->domain) )
+ ret = copy_from_guest(c.nat, op->u.vcpucontext.ctxt, 1);
+#ifdef CONFIG_COMPAT
+ else
+ ret = copy_from_guest(c.cmp,
+ guest_handle_cast(op->u.vcpucontext.ctxt,
+ void), 1);
+#endif
+ ret = ret ? -EFAULT : 0;
+
+ if ( ret == 0 )
+ {
+ domain_pause(d);
+ ret = arch_set_info_guest(v, c);
+ domain_unpause(d);
}
+
+ svc_out:
+ xfree(c.nat);
+ put_domain(d);
}
break;
if ( (d = domain_create(dom, domcr_flags)) == NULL )
break;
- ret = 0;
- switch ( (op->u.createdomain.flags >> XEN_DOMCTL_CDF_WORDSIZE_SHIFT)
- & XEN_DOMCTL_CDF_WORDSIZE_MASK )
- {
- case 0:
- if ( !IS_COMPAT(current->domain) )
- op->u.createdomain.flags |= BITS_PER_LONG
- << XEN_DOMCTL_CDF_WORDSIZE_SHIFT;
#ifdef CONFIG_COMPAT
- else
- {
- op->u.createdomain.flags |= COMPAT_BITS_PER_LONG
- << XEN_DOMCTL_CDF_WORDSIZE_SHIFT;
- case COMPAT_BITS_PER_LONG:
- ret = switch_compat(d);
- }
-#endif
- break;
- case BITS_PER_LONG:
- break;
- default:
- ret = -EINVAL;
- break;
- }
- if ( ret )
+ if ( IS_COMPAT(current->domain) && ((ret = switch_compat(d)) != 0) )
break;
+#endif
+
+ ret = 0;
memcpy(d->handle, op->u.createdomain.handle,
sizeof(xen_domain_handle_t));
case XEN_DOMCTL_getvcpucontext:
{
- vcpu_guest_context_u c;
- struct domain *d;
- struct vcpu *v;
+ vcpu_guest_context_u c = { .nat = NULL };
+ struct domain *d;
+ struct vcpu *v;
ret = -ESRCH;
if ( (d = find_domain_by_id(op->domain)) == NULL )
vcpu_unpause(v);
if ( !IS_COMPAT(v->domain) )
- {
-#ifndef COMPAT
- if ( copy_to_guest(op->u.vcpucontext.ctxt, c.nat, 1) )
-#else
- if ( copy_to_guest(compat_handle_cast(op->u.vcpucontext.ctxt,
- void),
- c.nat, 1) )
-#endif
- ret = -EFAULT;
- }
+ ret = copy_to_guest(op->u.vcpucontext.ctxt, c.nat, 1);
#ifdef CONFIG_COMPAT
else
- {
-#ifndef COMPAT
- if ( copy_to_guest(guest_handle_cast(op->u.vcpucontext.ctxt, void),
- c.cmp, 1) )
-#else
- if ( copy_to_compat(op->u.vcpucontext.ctxt, c.cmp, 1) )
-#endif
- ret = -EFAULT;
- }
+ ret = copy_to_guest(guest_handle_cast(op->u.vcpucontext.ctxt,
+ void), c.cmp, 1);
#endif
- xfree(c.nat);
-
- if ( copy_to_guest(u_domctl, op, 1) )
+ if ( copy_to_guest(u_domctl, op, 1) || ret )
ret = -EFAULT;
getvcpucontext_out:
+ xfree(c.nat);
put_domain(d);
}
break;
}
break;
-#ifdef CONFIG_COMPAT
- case XEN_DOMCTL_set_compat:
- ret = switch_compat(find_domain_by_id(op->domain));
- break;
-
- case XEN_DOMCTL_set_native:
- ret = switch_native(find_domain_by_id(op->domain));
- break;
-#endif
-
default:
ret = arch_do_domctl(op, u_domctl);
break;
#include <asm/current.h>
#include <public/sysctl.h>
-#ifndef COMPAT
-typedef long ret_t;
-#define copy_to_xxx_offset copy_to_guest_offset
-#endif
-
-extern ret_t arch_do_sysctl(
+extern long arch_do_sysctl(
struct xen_sysctl *op, XEN_GUEST_HANDLE(xen_sysctl_t) u_sysctl);
-ret_t do_sysctl(XEN_GUEST_HANDLE(xen_sysctl_t) u_sysctl)
+long do_sysctl(XEN_GUEST_HANDLE(xen_sysctl_t) u_sysctl)
{
- ret_t ret = 0;
+ long ret = 0;
struct xen_sysctl curop, *op = &curop;
static DEFINE_SPINLOCK(sysctl_lock);
put_domain(d);
- if ( copy_to_xxx_offset(op->u.getdomaininfolist.buffer,
- num_domains, &info, 1) )
+ if ( copy_to_guest_offset(op->u.getdomaininfolist.buffer,
+ num_domains, &info, 1) )
{
ret = -EFAULT;
break;
compat/acm.h \
compat/acm_ops.h \
compat/callback.h \
- compat/domctl.h \
compat/elfnote.h \
compat/event_channel.h \
compat/features.h \
compat/physdev.h \
compat/platform.h \
compat/sched.h \
- compat/sysctl.h \
compat/trace.h \
compat/vcpu.h \
compat/version.h \
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
- * Copyright (c) 2004-2006, K A Fraser
+ * Copyright (c) 2004-2007, K A Fraser
*/
#ifndef __XEN_PUBLIC_ARCH_X86_XEN_X86_32_H__
#define machine_to_phys_mapping ((unsigned long *)MACH2PHYS_VIRT_START)
#endif
+/* 32-/64-bit invariability for control interfaces (domctl/sysctl). */
+#if defined(__XEN__) || defined(__XEN_TOOLS__)
+#undef __DEFINE_XEN_GUEST_HANDLE
+#define __DEFINE_XEN_GUEST_HANDLE(name, type) \
+ typedef struct { type *p; } \
+ __guest_handle_ ## name; \
+ typedef struct { union { type *p; uint64_aligned_t q; }; } \
+ __guest_handle_64_ ## name
+#undef set_xen_guest_handle
+#define set_xen_guest_handle(hnd, val) \
+ do { if ( sizeof(hnd) == 8 ) *(uint64_t *)&(hnd) = 0; \
+ (hnd).p = val; \
+ } while ( 0 )
+#define uint64_aligned_t uint64_t __attribute__((aligned(8)))
+#define XEN_GUEST_HANDLE_64(name) __guest_handle_64_ ## name
+#endif
+
#ifndef __ASSEMBLY__
struct cpu_user_regs {
#define get_xen_guest_handle(val, hnd) do { val = (hnd).p; } while (0)
#endif
+#if defined(__i386__)
+#include "xen-x86_32.h"
+#elif defined(__x86_64__)
+#include "xen-x86_64.h"
+#endif
+
#ifndef __ASSEMBLY__
/* Guest handles for primitive C types. */
__DEFINE_XEN_GUEST_HANDLE(uchar, unsigned char);
DEFINE_XEN_GUEST_HANDLE(xen_pfn_t);
#endif
-#if defined(__i386__)
-#include "xen-x86_32.h"
-#elif defined(__x86_64__)
-#include "xen-x86_64.h"
-#endif
-
/*
* SEGMENT DESCRIPTOR TABLES
*/
#include "xen.h"
-#define XEN_DOMCTL_INTERFACE_VERSION 0x00000004
+#define XEN_DOMCTL_INTERFACE_VERSION 0x00000005
struct xenctl_cpumap {
- XEN_GUEST_HANDLE(uint8_t) bitmap;
+ XEN_GUEST_HANDLE_64(uint8_t) bitmap;
uint32_t nr_cpus;
};
/* Is this an HVM guest (as opposed to a PV guest)? */
#define _XEN_DOMCTL_CDF_hvm_guest 0
#define XEN_DOMCTL_CDF_hvm_guest (1U<<_XEN_DOMCTL_CDF_hvm_guest)
-#define XEN_DOMCTL_CDF_WORDSIZE_MASK 255
-#define XEN_DOMCTL_CDF_WORDSIZE_SHIFT 24
uint32_t flags;
};
typedef struct xen_domctl_createdomain xen_domctl_createdomain_t;
#define XEN_DOMINF_shutdownmask 255
#define XEN_DOMINF_shutdownshift 16
uint32_t flags; /* XEN_DOMINF_* */
- uint64_t tot_pages;
- uint64_t max_pages;
- uint64_t shared_info_frame; /* GMFN of shared_info struct */
- uint64_t cpu_time;
+ uint64_aligned_t tot_pages;
+ uint64_aligned_t max_pages;
+ uint64_aligned_t shared_info_frame; /* GMFN of shared_info struct */
+ uint64_aligned_t cpu_time;
uint32_t nr_online_vcpus; /* Number of VCPUs currently online. */
uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
uint32_t ssidref;
struct xen_domctl_getmemlist {
/* IN variables. */
/* Max entries to write to output buffer. */
- uint64_t max_pfns;
+ uint64_aligned_t max_pfns;
/* Start index in guest's page list. */
- uint64_t start_pfn;
- XEN_GUEST_HANDLE(xen_pfn_t) buffer;
+ uint64_aligned_t start_pfn;
+ XEN_GUEST_HANDLE_64(uint64_t) buffer;
/* OUT variables. */
- uint64_t num_pfns;
+ uint64_aligned_t num_pfns;
};
typedef struct xen_domctl_getmemlist xen_domctl_getmemlist_t;
DEFINE_XEN_GUEST_HANDLE(xen_domctl_getmemlist_t);
struct xen_domctl_getpageframeinfo {
/* IN variables. */
- uint64_t gmfn; /* GMFN to query */
+ uint64_aligned_t gmfn; /* GMFN to query */
/* OUT variables. */
/* Is the page PINNED to a type? */
uint32_t type; /* see above type defs */
#define XEN_DOMCTL_getpageframeinfo2 8
struct xen_domctl_getpageframeinfo2 {
/* IN variables. */
- uint64_t num;
+ uint64_aligned_t num;
/* IN/OUT variables. */
- XEN_GUEST_HANDLE(ulong) array;
+ XEN_GUEST_HANDLE_64(uint32_t) array;
};
typedef struct xen_domctl_getpageframeinfo2 xen_domctl_getpageframeinfo2_t;
DEFINE_XEN_GUEST_HANDLE(xen_domctl_getpageframeinfo2_t);
uint32_t mb; /* Shadow memory allocation in MB */
/* OP_PEEK / OP_CLEAN */
- XEN_GUEST_HANDLE(ulong) dirty_bitmap;
- uint64_t pages; /* Size of buffer. Updated with actual size. */
+ XEN_GUEST_HANDLE_64(uint8_t) dirty_bitmap;
+ uint64_aligned_t pages; /* Size of buffer. Updated with actual size. */
struct xen_domctl_shadow_op_stats stats;
};
typedef struct xen_domctl_shadow_op xen_domctl_shadow_op_t;
#define XEN_DOMCTL_max_mem 11
struct xen_domctl_max_mem {
/* IN variables. */
- uint64_t max_memkb;
+ uint64_aligned_t max_memkb;
};
typedef struct xen_domctl_max_mem xen_domctl_max_mem_t;
DEFINE_XEN_GUEST_HANDLE(xen_domctl_max_mem_t);
#define XEN_DOMCTL_getvcpucontext 13
struct xen_domctl_vcpucontext {
uint32_t vcpu; /* IN */
- XEN_GUEST_HANDLE(vcpu_guest_context_t) ctxt; /* IN/OUT */
+ XEN_GUEST_HANDLE_64(vcpu_guest_context_t) ctxt; /* IN/OUT */
};
typedef struct xen_domctl_vcpucontext xen_domctl_vcpucontext_t;
DEFINE_XEN_GUEST_HANDLE(xen_domctl_vcpucontext_t);
uint8_t online; /* currently online (not hotplugged)? */
uint8_t blocked; /* blocked waiting for an event? */
uint8_t running; /* currently scheduled on its CPU? */
- uint64_t cpu_time; /* total cpu time consumed (ns) */
+ uint64_aligned_t cpu_time; /* total cpu time consumed (ns) */
uint32_t cpu; /* current mapping */
};
typedef struct xen_domctl_getvcpuinfo xen_domctl_getvcpuinfo_t;
uint32_t cmd; /* XEN_DOMCTL_SCHEDOP_* */
union {
struct xen_domctl_sched_sedf {
- uint64_t period;
- uint64_t slice;
- uint64_t latency;
+ uint64_aligned_t period;
+ uint64_aligned_t slice;
+ uint64_aligned_t latency;
uint32_t extratime;
uint32_t weight;
} sedf;
#define XEN_DOMCTL_iomem_permission 20
struct xen_domctl_iomem_permission {
- uint64_t first_mfn; /* first page (physical page number) in range */
- uint64_t nr_mfns; /* number of pages in range (>0) */
- uint8_t allow_access; /* allow (!0) or deny (0) access to range? */
+ uint64_aligned_t first_mfn;/* first page (physical page number) in range */
+ uint64_aligned_t nr_mfns; /* number of pages in range (>0) */
+ uint8_t allow_access; /* allow (!0) or deny (0) access to range? */
};
typedef struct xen_domctl_iomem_permission xen_domctl_iomem_permission_t;
DEFINE_XEN_GUEST_HANDLE(xen_domctl_iomem_permission_t);
#define XEN_DOMCTL_hypercall_init 22
struct xen_domctl_hypercall_init {
- uint64_t gmfn; /* GMFN to be initialised */
+ uint64_aligned_t gmfn; /* GMFN to be initialised */
};
typedef struct xen_domctl_hypercall_init xen_domctl_hypercall_init_t;
DEFINE_XEN_GUEST_HANDLE(xen_domctl_hypercall_init_t);
#define _XEN_DOMAINSETUP_query 1 /* Get parameters (for save) */
#define XEN_DOMAINSETUP_query (1UL<<_XEN_DOMAINSETUP_query)
typedef struct xen_domctl_arch_setup {
- uint64_t flags; /* XEN_DOMAINSETUP_* */
+ uint64_aligned_t flags; /* XEN_DOMAINSETUP_* */
#ifdef __ia64__
- uint64_t bp; /* mpaddr of boot param area */
- uint64_t maxmem; /* Highest memory address for MDT. */
- uint64_t xsi_va; /* Xen shared_info area virtual address. */
- uint32_t hypercall_imm; /* Break imm for Xen hypercalls. */
+ uint64_aligned_t bp; /* mpaddr of boot param area */
+ uint64_aligned_t maxmem; /* Highest memory address for MDT. */
+ uint64_aligned_t xsi_va; /* Xen shared_info area virtual address. */
+ uint32_t hypercall_imm; /* Break imm for Xen hypercalls. */
#endif
} xen_domctl_arch_setup_t;
DEFINE_XEN_GUEST_HANDLE(xen_domctl_arch_setup_t);
#define XEN_DOMCTL_gethvmcontext 33
#define XEN_DOMCTL_sethvmcontext 34
typedef struct xen_domctl_hvmcontext {
- XEN_GUEST_HANDLE(hvm_domain_context_t) ctxt; /* IN/OUT */
+ XEN_GUEST_HANDLE_64(hvm_domain_context_t) ctxt; /* IN/OUT */
} xen_domctl_hvmcontext_t;
DEFINE_XEN_GUEST_HANDLE(xen_domctl_hvmcontext_t);
typedef struct xen_domctl_real_mode_area xen_domctl_real_mode_area_t;
DEFINE_XEN_GUEST_HANDLE(xen_domctl_real_mode_area_t);
-#define XEN_DOMCTL_set_compat 42
-#define XEN_DOMCTL_set_native 43
-
struct xen_domctl {
uint32_t cmd;
uint32_t interface_version; /* XEN_DOMCTL_INTERFACE_VERSION */
#include "xen.h"
#include "domctl.h"
-#define XEN_SYSCTL_INTERFACE_VERSION 0x00000002
+#define XEN_SYSCTL_INTERFACE_VERSION 0x00000003
/*
* Read console content from Xen buffer ring.
struct xen_sysctl_readconsole {
/* IN variables. */
uint32_t clear; /* Non-zero -> clear after reading. */
- XEN_GUEST_HANDLE(char) buffer; /* Buffer start */
+ XEN_GUEST_HANDLE_64(char) buffer; /* Buffer start */
/* IN/OUT variables. */
uint32_t count; /* In: Buffer size; Out: Used buffer size */
};
struct xenctl_cpumap cpu_mask;
uint32_t evt_mask;
/* OUT variables */
- uint64_t buffer_mfn;
+ uint64_aligned_t buffer_mfn;
uint32_t size;
};
typedef struct xen_sysctl_tbuf_op xen_sysctl_tbuf_op_t;
uint32_t sockets_per_node;
uint32_t nr_nodes;
uint32_t cpu_khz;
- uint64_t total_pages;
- uint64_t free_pages;
- uint64_t scrub_pages;
+ uint64_aligned_t total_pages;
+ uint64_aligned_t free_pages;
+ uint64_aligned_t scrub_pages;
uint32_t hw_cap[8];
};
typedef struct xen_sysctl_physinfo xen_sysctl_physinfo_t;
uint32_t nr_counters; /* number of counters description */
uint32_t nr_vals; /* number of values */
/* counter information (or NULL) */
- XEN_GUEST_HANDLE(xen_sysctl_perfc_desc_t) desc;
+ XEN_GUEST_HANDLE_64(xen_sysctl_perfc_desc_t) desc;
/* counter values (or NULL) */
- XEN_GUEST_HANDLE(xen_sysctl_perfc_val_t) val;
+ XEN_GUEST_HANDLE_64(xen_sysctl_perfc_val_t) val;
};
typedef struct xen_sysctl_perfc_op xen_sysctl_perfc_op_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_perfc_op_t);
/* IN variables. */
domid_t first_domain;
uint32_t max_domains;
- XEN_GUEST_HANDLE(xen_domctl_getdomaininfo_t) buffer;
+ XEN_GUEST_HANDLE_64(xen_domctl_getdomaininfo_t) buffer;
/* OUT variables. */
uint32_t num_domains;
};
#endif /* !__ASSEMBLY__ */
+/* Default definitions for macros used by domctl/sysctl. */
+#if defined(__XEN__) || defined(__XEN_TOOLS__)
+#ifndef uint64_aligned_t
+#define uint64_aligned_t uint64_t
+#endif
+#ifndef XEN_GUEST_HANDLE_64
+#define XEN_GUEST_HANDLE_64(name) XEN_GUEST_HANDLE(name)
+#endif
+#endif
+
#endif /* __XEN_PUBLIC_XEN_H__ */
/*
void free_domain(struct domain *d);
struct xen_domctl_getdomaininfo;
-void getdomaininfo(
- struct domain *d, struct xen_domctl_getdomaininfo *info);
-struct compat_domctl_getdomaininfo;
-void compat_getdomaininfo(
- struct domain *d, struct compat_domctl_getdomaininfo *info);
+void getdomaininfo(struct domain *d, struct xen_domctl_getdomaininfo *info);
/*
* Arch-specifics.
unsigned long initrd_start, unsigned long initrd_len,
char *cmdline);
-typedef union {
- struct xen_domctl_vcpucontext *nat;
- struct compat_domctl_vcpucontext *cmp;
-} xen_domctl_vcpucontext_u __attribute__((__transparent_union__));
-
-int set_info_guest(struct domain *d, xen_domctl_vcpucontext_u);
-
struct domain *find_domain_by_id(domid_t dom);
void domain_destroy(struct domain *d);
void domain_kill(struct domain *d);
! trap_info arch-x86/xen.h
! vcpu_guest_context arch-x86/xen.h
? acm_getdecision acm_ops.h
-! ctl_cpumap domctl.h
-! domctl_scheduler_op domctl.h
-! domctl_shadow_op domctl.h
-! domctl_shadow_op_stats domctl.h
? evtchn_alloc_unbound event_channel.h
? evtchn_bind_interdomain event_channel.h
? evtchn_bind_ipi event_channel.h
! sched_poll sched.h
? sched_remote_shutdown sched.h
? sched_shutdown sched.h
-? sysctl_perfc_desc sysctl.h
-! sysctl_perfc_op sysctl.h
-! sysctl_tbuf_op sysctl.h
? t_buf trace.h
! vcpu_runstate_info vcpu.h
? xenoprof_init xenoprof.h
projects / xen.git / commitdiff